Mesdames, Messieurs, voici python 3.6¶
Mais ne me croyez pas sur parole, on va vérifier
(présentation en avant-deuxième !)
In [6]:
import sys
print(sys.version)
Yay¶
Bon quoi de neuf, du coup
Les Strings formattées encore améliorées¶
Vous connaissez déjà la syntaxe suivante
In [7]:
language = "Python"
year = 2016
template = "Bonjour le dernier Meetup %(language)s de l'année %(year)d"
print(template % {"language": language, "year": year})
Vous avez peut-être l'habitude d'utiliser
In [8]:
template = "Bonjour le dernier Meetup %s de l'année %d"
print(template % (language, year))
Mais c'est long à taper.
Ça c'était en Python 2.
Vous connaissez aussi la nouvelle syntaxe
In [9]:
template = "Bonjour le dernier Meetup {language} de l'année {year}"
print(template.format(language=language, year=year))
Mais c'est toujours long à taper...
Et peut-etre même savez-vous que ca permet de faire des choses merveilleuses comme
In [10]:
print("{:~^30}".format(" Bonjour Python ! "))
In [11]:
from datetime import datetime
print("{:%Y-%m-%d}".format(datetime.now()))
(protip : plongez vous dans les arcanes du .format sur http://pyformat.info)
Et maintenant vous avez... (roulement de tambours)¶
In [12]:
f"Bonjour le dernier Meetup {language} de {year}"
Out[12]:
In [13]:
f"Bonjour le dernier Meetup {language} de {datetime.now():%Y}"
Out[13]:
Les annotations de types pour les variables¶
Python, circa 2014 (a.k.a Python 3.4-)
In [14]:
first_grade = 3
grades = [first_grade, 2, 5.7]
class Student:
notes = []
def average(self, multiplier=1):
if not self.grades:
return "Aucune note"
average = sum(self.grades) / len(self.grades)
average *= multiplier
return "Average grade: {:.1f}".format(average)
s = Student()
s.grades = grades
print(s.average())
Python, circa 2015 (a.k.a Python 3.5)
In [15]:
first_grade = 3
grades = [first_grade, 2, 5.7]
class Student:
notes = []
def average(self, multiplier: float=1) -> str:
if not self.grades:
return "Aucune note"
average = sum(self.grades) / len(self.grades)
average *= multiplier
return "Average grade: {:.1f}".format(average)
s = Student()
s.grades = grades
print(s.average())
Python, circa 2016 (a.k.a Python 3.6)
In [16]:
from typing import List
first_grade: int = 3
grades: List[float] = [first_grade, 2, 5.7]
class Student:
notes: List[float] = []
def average(self, multiplier: float=1) -> str:
if not self.grades:
return "Aucune note"
average: float = sum(self.grades) / len(self.grades)
average *= multiplier
return f"Average grade: {average:.1f}"
s:Student = Student()
s.grades = grades
print(s.average())
Des grands nombres enfin lisibles¶
In [17]:
print(1_000_000_000_000_000)
print(f"{0x_FF_FF_FF_FF:X}")
Des nouvelles méthodes magiques¶
Pour l'héritage...
In [18]:
class PluginBase:
subclasses = []
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
cls.subclasses.append(cls)
class Plugin1(PluginBase):
pass
class Plugin2(PluginBase):
pass
print(PluginBase.subclasses)
... et pour la composition
In [19]:
class IntField:
# this is the new initializer:
def __set_name__(self, owner, name):
self.model = owner
self.name = name
def whats_your_name(self):
print(f"{self.model} m'a nommé {self.name}")
class ModelA:
value_a = IntField()
class ModelB:
value_b = IntField()
In [20]:
ModelA().value_a.whats_your_name()
ModelB().value_b.whats_your_name()
Toujours plus d'asynchrone¶
L'API d'asyncio est stabilisée et on peut maintenant créer des générateurs asynchrones
pathlib amélioré !¶
In [21]:
import os, pathlib
path = pathlib.Path() / ".."
print(os.listdir(path))
In [22]:
path = path / "jupyter" / "Python 3.6.ipynb"
print(open(path))
In [23]:
print(path.parent)
In [24]:
print(path.suffix)
In [25]:
print(path.stem)
Python connait tau !¶
In [26]:
from math import tau, pi, cos, sin
print(tau == 2 * pi)
print(f"{cos(tau):.2f}, {sin(tau):.2f}")
Les dictionnaires sont maintenant ordonnés¶
Bonus : ils sont plus compacts en mémoire !
In [27]:
list({i: i for i in range(100)}) == list(range(100))
Out[27]:
Le module secrets pour générer des clés¶
In [28]:
import secrets
print(f"{secrets.randbits(2048):X}")
